package com.xuecheng.media.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.j256.simplemagic.ContentInfo;
import com.j256.simplemagic.ContentInfoUtil;
import com.xuecheng.base.exception.XueChengPlusException;
import com.xuecheng.base.model.PageParams;
import com.xuecheng.base.model.PageResult;
import com.xuecheng.base.model.RestResponse;
import com.xuecheng.media.config.MinioConfig;
import com.xuecheng.media.mapper.MediaFilesMapper;
import com.xuecheng.media.mapper.MediaProcessMapper;
import com.xuecheng.media.model.dto.QueryMediaParamsDto;
import com.xuecheng.media.model.dto.UploadFilesParamDto;
import com.xuecheng.media.model.dto.UploadFilesResultDto;
import com.xuecheng.media.model.po.MediaFiles;
import com.xuecheng.media.model.po.MediaProcess;
import com.xuecheng.media.service.MediaFileService;
import io.minio.*;
import io.minio.messages.DeleteError;
import io.minio.messages.DeleteObject;
import lombok.extern.slf4j.Slf4j;

import org.apache.commons.compress.utils.IOUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.DigestUtils;
import org.springframework.web.multipart.MultipartFile;

import java.io.*;

import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @description TODO
 * @author Mr.M
 * @date 2022/9/10 8:58
 * @version 1.0
 */
 @Service
 @Slf4j
public class MediaFileServiceImpl implements MediaFileService {

    @Autowired
    MediaFilesMapper mediaFilesMapper;

    @Autowired
    private MinioConfig minioConfig;

    //存储视频文件
    @Value("${minio.bucket.videofiles}")
    private String bucket_video;
    //存储普通文件
    @Value("${minio.bucket.files}")
    private String bucket_MediaFiles;
    @Autowired
    private MediaFileService currentpry;
    @Autowired
    private MediaProcessMapper mediaProcessMapper;

    @Override
    public PageResult<MediaFiles> queryMediaFiels(Long companyId, PageParams pageParams, QueryMediaParamsDto queryMediaParamsDto) {

        //构建查询条件对象
        LambdaQueryWrapper<MediaFiles> queryWrapper = new LambdaQueryWrapper<>();

        //分页对象
        Page<MediaFiles> page = new Page<>(pageParams.getPageNo(), pageParams.getPageSize());
        // 查询数据内容获得结果
        Page<MediaFiles> pageResult = mediaFilesMapper.selectPage(page, queryWrapper);
        // 获取数据列表
        List<MediaFiles> list = pageResult.getRecords();
        // 获取数据总数
        long total = pageResult.getTotal();
        // 构建结果集
        PageResult<MediaFiles> mediaListResult = new PageResult<>(list, total, pageParams.getPageNo(), pageParams.getPageSize());
        return mediaListResult;

    }

    public boolean upload(String localPath, String bucket, String objectFilename, String contentType) {
        try {
            UploadObjectArgs uploadObjectArgs = UploadObjectArgs.builder()
                    .bucket(bucket)//桶
                    .filename(localPath)//上传文件的本地地址
                    .object(objectFilename)//上传文件的重命名，再bucket中的名字
                    .contentType(contentType)//文件类型
                    .build();
            minioConfig.minioClient().uploadObject(uploadObjectArgs);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            log.info("上传文件出错,bucket{},ObjectName{},错误信息{}", bucket, objectFilename, e.getMessage());
        }
        return false;
    }

    //获取到minType
    public String getMinType(String extension) {
        if(extension == null){
            extension = "";
        }
        //根据拓展名取出minType
        ContentInfo contentInfo = ContentInfoUtil.findMimeTypeMatch(extension);
        String minType = MediaType.APPLICATION_OCTET_STREAM_VALUE;//通用的mintype字节流
        if (contentInfo != null) {
            minType = contentInfo.getMimeType();
        }
        return minType;
    }

    //获取到bucket的存储路径，按照每天的日期进行存储
    public String getDefaultPath() {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");//格式化日期
        String FolderPath = dateFormat.format(new Date()).replace("-", "/") + "/";//拼接默认桶的文件路径
        return FolderPath;
    }

    //根据文件获取到MD5的值
    public String getFileMD5(File file) {
        try {
            FileInputStream inputStream = new FileInputStream(file);
            String fileMD5 = DigestUtils.md5DigestAsHex(inputStream);
            return fileMD5;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    //代码复用准备，向数据库添加文件上传信息
    @Transactional  //开启事务
    public MediaFiles addMediaInfoToSQL(Long companyId, String fileMD5,
                                        UploadFilesParamDto uploadFilesParamDto,
                                        String bucket, String objectName) {
        //把文件信息插入数据库
        MediaFiles mediaFiles = mediaFilesMapper.selectById(fileMD5);
        //如果数据库内容为空，那么就添加
        if (mediaFiles == null) {
            mediaFiles = new MediaFiles();
            BeanUtils.copyProperties(uploadFilesParamDto, mediaFiles);
            mediaFiles.setId(fileMD5);
            mediaFiles.setCompanyId(companyId);
            mediaFiles.setBucket(bucket);
            mediaFiles.setFilePath(objectName);
            mediaFiles.setFileId(fileMD5);
            mediaFiles.setUrl("/" + bucket + "/" + objectName);
            mediaFiles.setCreateDate(LocalDateTime.now());
            mediaFiles.setStatus("1");
            mediaFiles.setAuditStatus("002003");

            int insert = mediaFilesMapper.insert(mediaFiles);
            if (insert <= 0) {
                log.info("文件信息保存失败,{}", bucket + objectName);
            }
            //添加待处理任务表
            addWaitingTask(mediaFiles);
            log.debug("保存文件信息到数据库成功,{}", mediaFiles.toString());
        }
        return mediaFiles;
    }

    /**
     * 添加待处理任务
     * @param mediaFiles 媒资文件信息
     */
    private void addWaitingTask(MediaFiles mediaFiles){
        //文件名称
        String filename = mediaFiles.getFilename();
        //文件扩展名
        String exension = filename.substring(filename.lastIndexOf("."));
        //文件mimeType
        String mimeType = getMinType(exension);
        //如果是avi视频添加到视频待处理表
        if(mimeType.equals("video/x-msvideo")){
            MediaProcess mediaProcess = new MediaProcess();
            BeanUtils.copyProperties(mediaFiles,mediaProcess);
            mediaProcess.setStatus("1");//未处理
            mediaProcess.setFailCount(0);//失败次数默认为0
            mediaProcess.setUrl(null);//上传的视频默认为空
            mediaProcessMapper.insert(mediaProcess);
        }
    }

    /**
     * 文件上传业务
     *
     * @param companyId
     * @param uploadFilesParamDto
     * @param localPath
     * @return
     */
    @Override
    public UploadFilesResultDto FileUpload(Long companyId, UploadFilesParamDto uploadFilesParamDto, String localPath) {
        //获取到文件类型
        String filename = uploadFilesParamDto.getFilename();
        String extension = filename.substring(filename.lastIndexOf("."));//分割文件名和文件后缀
        String minType = getMinType(extension);
        //获得文件再bucket中的存储路径
        String folderPath = getDefaultPath();
        //获取到文件的MD5值
        String fileMD5 = getFileMD5(new File(localPath));
        //拼接得到objectName
        String objectName = folderPath + fileMD5 + extension;//拼接存储到bucket中的自定义的文件名
        //开始上传文件
        boolean upload = upload(localPath, bucket_MediaFiles, objectName, minType);
        if (!upload) {
            XueChengPlusException.cast("文件上传失败");
        }
        //TODO：把文件信息插入数据库,这里把关于数据库的操作提取出来，
        // 然后开启事务不让网络上传和数据库操作放一起，会造成延时，
        // 采用自己注入自己的方式，保证是同一个代理对象对数据库进行操作，防止事务失效
        MediaFiles mediaFiles = currentpry.addMediaInfoToSQL(companyId, fileMD5, uploadFilesParamDto, bucket_MediaFiles, objectName);
        //准备返回的对象
        if (mediaFiles == null) {
            XueChengPlusException.cast("文件上传后保存文件信息失败");
        }
        UploadFilesResultDto resultDto = new UploadFilesResultDto();
        BeanUtils.copyProperties(mediaFiles, resultDto);
        return resultDto;
    }

    /**
     * @param fileMd5 文件的md5
     * @return false不存在，true存在
     * @description 检查文件是否存在
     */
    @Override
    public RestResponse<Boolean> checkFile(String fileMd5) {
        MinioClient minioClient = minioConfig.minioClient();
        //首先检查数据库中是否含有该视频的数据
        MediaFiles mediaFiles = mediaFilesMapper.selectById(fileMd5);
        //检查Minio中是否还有该数据
        if (mediaFiles != null) {
            String bucket = mediaFiles.getBucket();
            String ObjectName = mediaFiles.getFilePath();
            GetObjectArgs getObjectArgs = GetObjectArgs.builder()
                    .bucket(bucket)
                    .object(ObjectName)
                    .build();
            try {
                FilterInputStream inputStream = minioClient.getObject(getObjectArgs);
                //如果object != null 就说明Minio中存在
                if (inputStream != null) {
                    return RestResponse.success(true);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        //不存在的情况
        return RestResponse.success(false);
    }

    /**
     * @param fileMd5    文件的md5
     * @param chunkIndex 分块序号
     * @return false不存在，true存在
     * @description 检查分块是否存在
     */
    @Override
    public RestResponse<Boolean> checkChunk(String fileMd5, int chunkIndex) {
        //查询分块，不查数据库，主要是拼装存储路劲，分块的存储路径是MD5前两位为存储目录，chunk存储分块文件、
        //根据MD5得到分块的存储路径
        String chunkFilePath = getChunkPath(fileMd5);

        MinioClient minioClient = minioConfig.minioClient();

        //检查Minio中是否还有该数据

            GetObjectArgs getObjectArgs = GetObjectArgs.builder()
                    .bucket(bucket_video)
                    .object(chunkFilePath+ chunkIndex)
                    .build();
            try {
                FilterInputStream inputStream = minioClient.getObject(getObjectArgs);
                //如果object != null 就说明Minio中存在
                if (inputStream != null) {
                    return RestResponse.success(true);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        return RestResponse.success(false);
        }

    @Override
    public RestResponse uploadChunk(String  filePath, String fileMd5, int chunk) {
        //分块文件的路径
        String chunkPath = getChunkPath(fileMd5) + chunk;
        //获得MinioType
        String minType = getMinType(null);

        //上传分块
        boolean upload = upload(filePath, bucket_video, chunkPath, minType);
        if(!upload){
            //说明上传失败
            return RestResponse.validfail(false,"分块文件上传失败");
        }
        return RestResponse.success(true);
    }

    /**
     * 合并分块
     * @param companyId，公司ID用来标识一个公司
     * @param fileMd5，文件的名字
     * @param chunkTotal，分块的总数
     * @param uploadFileParamsDto，上传参数
     * @return
     */
    @Override
    public RestResponse mergechunks(Long companyId, String fileMd5, int chunkTotal, UploadFilesParamDto uploadFileParamsDto) {
        //找到目录下的分块文件，合并
        List<ComposeSource> sourceList = new ArrayList<>();
        //根据MD5的值获取到分块所在的目录
        String chunkPath = getChunkPath(fileMd5);
        //获取源文件名称
        String filename = uploadFileParamsDto.getFilename();
        //获取到源文件的拓展名
        String extension = filename.substring(filename.lastIndexOf("."));
        //根据MD5获取到合并后文件的目录和名称
        String mergeFilePath  = getObjectNamePath(fileMd5, extension);
        //找到所有的块文件
        for(int i = 0; i < chunkTotal; i ++){
            //指定分块的信息
            ComposeSource source = ComposeSource.builder()
                    .bucket(bucket_video)
                    .object(chunkPath+i)
                    .build();
            sourceList.add(source);
        }
        //指定合并后的文件obectName等信息
        ComposeObjectArgs composeObjectArgs = ComposeObjectArgs.builder()
                .bucket(bucket_video)
                .object(mergeFilePath )//合并后文件的objectName
                .sources(sourceList)
                .build();

        //使用Minio提供的接口直接合并,这里要求分块的大小至少为5MB
        //TODO:开始合并文件
        MinioClient minioClient = minioConfig.minioClient();
        try {
            minioClient.composeObject(composeObjectArgs);
        }catch (Exception e){
            log.info("视频合并失败,bucket = {}，objectNamePath = {},错误信息：{}",bucket_video,mergeFilePath ,e.getMessage());
            return RestResponse.validfail(false,"合并文件异常");
        }
        //TODO:校验合并后的文件和上传的源文件是否一致
        File minioFile = downloadFileFromMinIO(bucket_video,mergeFilePath);
        if(minioFile == null){
            log.debug("下载合并后文件失败,mergeFilePath:{}",mergeFilePath);
            return RestResponse.validfail(false, "下载合并后文件失败。");
        }

        try (InputStream newFileInputStream = new FileInputStream(minioFile)) {
            //minio上文件的md5值
            String md5Hex = DigestUtils.md5DigestAsHex(newFileInputStream);
            //比较md5值，不一致则说明文件不完整
            if(!fileMd5.equals(md5Hex)){
                return RestResponse.validfail(false, "文件合并校验失败，最终上传失败。");
            }
            //文件大小
            uploadFileParamsDto.setFileSize(minioFile.length());
        }catch (Exception e){
            log.debug("校验文件失败,fileMd5:{},异常:{}",fileMd5,e.getMessage(),e);
            return RestResponse.validfail(false, "文件合并校验失败，最终上传失败。");
        }finally {
            if(minioFile!=null){
                minioFile.delete();
            }
        }
        //合并之后把文件信息保存到数据库
        //TODO:这里的添加功能必须使用用同一个代理对象调用，否则事务不起作用
        MediaFiles mediaFiles = currentpry.addMediaInfoToSQL(companyId, fileMd5, uploadFileParamsDto, bucket_video, mergeFilePath);
        if(mediaFiles == null){
            return RestResponse.validfail(false,"文件入库失败");
        }
        //TODO:把分块清理干净
        clearChunkFiles(chunkPath,chunkTotal);
        return RestResponse.success(true);
    }
    /**
     * 清除分块文件
     * @param chunkFileFolderPath 分块文件路径
     * @param chunkTotal 分块文件总数
     */
    private void clearChunkFiles(String chunkFileFolderPath,int chunkTotal){

        try {
            List<DeleteObject> deleteObjects = Stream.iterate(0, i -> ++i)
                    .limit(chunkTotal)
                    .map(i -> new DeleteObject(chunkFileFolderPath.concat(Integer.toString(i))))
                    .collect(Collectors.toList());

            RemoveObjectsArgs removeObjectsArgs = RemoveObjectsArgs.builder().bucket(bucket_video).objects(deleteObjects).build();
            Iterable<Result<DeleteError>> results = minioConfig.minioClient().removeObjects(removeObjectsArgs);
            //单纯的额调用remove方法，并不能正真的删除，需要循环遍历一遍才能删除。
            results.forEach(r->{
                try {
                    DeleteError deleteError = r.get();
                } catch (Exception e) {
                    e.printStackTrace();
                    log.error("清楚分块文件失败,objectname:{}",e.getMessage());
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
            log.error("清楚分块文件失败,chunkFileFolderPath:{}",chunkFileFolderPath,e);
        }
    }
    /**
     * 从minio下载文件
     * @param bucket 桶
     * @param objectName 对象名称
     * @return 下载后的文件
     */
    public File downloadFileFromMinIO(String bucket,String objectName){
        //临时文件
        File minioFile = null;
        FileOutputStream outputStream = null;
        try{
            InputStream stream = minioConfig.minioClient().getObject(GetObjectArgs.builder()
                    .bucket(bucket)
                    .object(objectName)
                    .build());
            //创建临时文件
            minioFile=File.createTempFile("minio", ".merge");
            outputStream = new FileOutputStream(minioFile);
            IOUtils.copy(stream,outputStream);
            return minioFile;
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(outputStream!=null){
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }


    //组装合并后文件所在的目录和名称
    private String getObjectNamePath(String fileMd5,String fileExt){
        return fileMd5.substring(0,1)+"/"+fileMd5.substring(1,2)+"/"+fileMd5+"/"+fileMd5+fileExt;
    }
    public String getChunkPath(String MD5){
        return MD5.substring(0,1)+"/"+MD5.substring(1,2)+"/"+MD5+"/"+"chunk"+"/";
    }
}
